package cn.net.isir.service;

import cn.net.isir.core.BasicService;
import cn.net.isir.core.SetBasicDao;
import cn.net.isir.dao.MedalsDao;
import cn.net.isir.entity.Medals;
import cn.net.isir.utils.StringUtils;
import com.github.pagehelper.PageInfo;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.stream.Collectors;

@Service
public class MedalsService extends BasicService<Medals> {
    @SetBasicDao
    @Resource
    private MedalsDao medalsDao;

    @Override
    public PageInfo selectListByUser(Object parameter) {
        Medals medals = (Medals) parameter;
        if (StringUtils.isNotBlank(medals.getRank())) {
            try {
                String rank = URLDecoder.decode(medals.getRank(), StandardCharsets.UTF_8.name());
//                rank = java.net.URLEncoder.encode(rank, StandardCharsets.UTF_8.name());
                medals.setRank(rank);
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        }
        return medalsDao.selectPageList(medals, medals.getPageNo(), medals.getPageSize());
    }

    /**
     * 重新将品类进行排序(新增，修改的时候适用)
     *
     * @param medals 修改的品类
     */
    public void reSort(Medals medals) {

        Medals mQuery = new Medals();
        mQuery.setId(medals.getId());
        List<Medals> medalsList = medalsDao.selectList(null);//已经排序过的列表（排序号从小到大）
        int newIndex = medals.getSort();

        // 如果没有已经存在的序号，则无需重新排序
        boolean isExist = false;
        for (Medals m : medalsList) {
            if (m.getSort() == newIndex) {
                isExist = true;
                break;
            }
        }
        if (!isExist) {
            return;
        }

        // 新增的时候，找到要新增的位置，然后找出大于等于当前排序的，都+1
        if (StringUtils.isBlank(medals.getId())) {
//        categoryList.sort((o1, o2) -> o1.getSort() < o2.getSort() ? -1 : Objects.equals(o1.getSort(), o2.getSort()) ? 0 : 1);
            // 找出大于等于当前index的，然后下移更新
            List<Medals> needChanges = medalsList.stream().filter(m -> m.getSort() >= newIndex).collect(Collectors.toList());
            if (needChanges.size() > 0) {
                needChanges.forEach(m -> {
                    m.setSort(m.getSort() + 1);
                    medalsDao.update(m);
                });
            }
        }
        // 更新的时候
        if (StringUtils.isNotBlank(medals.getId())) {
            //分为两种情况：上移和下移
            Medals oldMedals = medalsDao.selectByPrimaryKey(medals.getId());
            int oldIndex = oldMedals.getSort();
            // 新排序等于旧排序，则则不移动
            if (oldMedals.getSort().equals(medals.getSort())) {
                return;
            }
            // 新排序小于旧排序，则表示上移
            if (medals.getSort() < oldMedals.getSort()) {
                // 找出小于旧index并且大于等于新index的，全部下移，然后上部腾出空给新的index
                List<Medals> needChanges = medalsList.stream()
                        .filter(m -> m.getSort() >= newIndex && m.getSort() < oldIndex)
                        .collect(Collectors.toList());
                // 下移，给新index腾出空
                needChanges.forEach(m -> {
                    m.setSort(m.getSort() + 1);
                    medalsDao.update(m);
                });
            }
            // 新排序大于旧排序，表示下移
            if (medals.getSort() > oldMedals.getSort()) {
                // 找出大于旧index并且小于等于旧index的，全部上移，然后下部腾出空给新的index
                List<Medals> needChanges = medalsList.stream()
                        .filter(m -> m.getSort() > oldIndex && m.getSort() <= newIndex)
                        .collect(Collectors.toList());
                // 下移，给新index腾出空
                needChanges.forEach(m -> {
                    m.setSort(m.getSort() - 1);
                    medalsDao.update(m);
                });
            }
            // 更新移动项排序
            Medals m2 = new Medals();
            m2.setId(medals.getId());
            m2.setSort(medals.getSort());
            medalsDao.update(m2);
        }
    }

    /**
     * 重新将品类进行排序(删除适用)
     *
     * @param id 删除的品类
     */
    public void reSort(String id) {
        Medals medals = medalsDao.selectByPrimaryKey(id);
        Medals mQuery = new Medals();
        mQuery.setId(medals.getId());
        List<Medals> medalsList = medalsDao.selectList(null);//已经排序过的列表（排序号从小到大）
        int newIndex = medals.getSort();
        // 找出大于等于当前index的，然后下移更新
        List<Medals> needChanges = medalsList.stream().filter(m -> m.getSort() > newIndex).collect(Collectors.toList());
        if (needChanges.size() > 0) {
            needChanges.forEach(m -> {
                m.setSort(m.getSort() - 1);
                medalsDao.update(m);
            });
        }
    }
}
